﻿package com.zouloux.core.base
{
	import flash.display.Loader;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.net.URLRequest;
	import flash.net.URLRequestMethod;
	import flash.net.URLVariables;
	import flash.system.Capabilities;
	import nl.demonsters.debugger.MonsterDebugger;
	
	/**
	 * Classe de préloader
	 * @author ZoulouX
	 */
	public class LoaderBase extends MovieClip
	{
		/**
		 * L'url par défaut
		 */
		public var url						:String			= "main.swf";
		
		/**
		 * Le loader
		 */
		private var _loader					:Loader;
		
		/**
		 * Les variables pour le chargement
		 */
		private var _variables				:URLVariables;
		
		/**
		 * Récupérer le ratio de chargement
		 */
		public function get progress ():Number
		{
			var coef:Number = _loader.contentLoaderInfo.bytesLoaded / _loader.contentLoaderInfo.bytesTotal;
			return coef;
		}
		
		/**
		 * Le constructeur
		 */
		public function LoaderBase ()
		{
			// Relayer la construction
			super();
		}
		
		/**
		 * Démarrer le chargement
		 * @param	url : Le lien du flash à charger, par défaut il utilise la variable url
		 */
		public function startLoading (pUrl:String = ""):void
		{
			// Utiliser l'url par défaut
			if (pUrl == "")
				pUrl = url;
			
			// Créer le loader
			_loader = new Loader();
			
			// Les variables
			_variables = new URLVariables();
			
			// Ce clip vient d'un loader
			_variables["fromLoader"] = true;
			
			// Récupérer tous les paramètres
			for (var i:* in loaderInfo.parameters)
			{
				// Injecter cette variable
				_variables[i] = loaderInfo.parameters[i];
			}
			
			// La requête
			var urlRequest:URLRequest;
			
			// Vérifier si on est en local
			if (Capabilities.playerType == "StandAlone" || Capabilities.playerType == "External")
				urlRequest = new URLRequest(pUrl);
			else
				urlRequest = new URLRequest(pUrl + "?" + _variables.toString());
			
			// Définir la méthode de chargement
			urlRequest.method = URLRequestMethod.POST;
			
			// Lancer le chargement
			_loader.load(urlRequest);
			
			// Ecouter ce qu'il se passe
			_loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loadSuccessHandler);
			_loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, loadErrorHandler);
			
			// La boucle
			addEventListener(Event.ENTER_FRAME, loopHandler);
		}
		
		/**
		 * La boucle enterFrame
		 * @param	event
		 */
		private function loopHandler (event:Event):void 
		{
			loop();
		}
		
		/**
		 * Chargement réussi
		 * @param	event
		 */
		private function loadSuccessHandler (event:Event = null):void
		{
			// Virer les event
			dispose();
			
			// Appeler la méthode correspondante
			success();
		}
		
		/**
		 * Chargement réussi
		 * @param	event
		 */
		private function loadErrorHandler (event:IOErrorEvent = null):void
		{
			// Virer les event
			dispose();
			
			// Appeler la méthode correspondante
			error();
		}
		
		/**
		 * Boucle enterFrame, à overrider
		 */
		public function loop ():void
		{
			
		}
		
		/**
		 * Chargement réussi, à overrider
		 */
		public function success ():void
		{
			
		}
		
		/**
		 * Erreur lors du chargement, à overrider
		 */
		public function error ():void
		{
			
		}
		
		/**
		 * Afficher le loader
		 */
		public function showContent ():void
		{
			addChild(_loader);
		}
		
		/**
		 * Le loader est effacé du stage
		 * @param	event
		 */
		public function dispose ():void
		{
			_loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR, loadErrorHandler);
			_loader.contentLoaderInfo.removeEventListener(Event.COMPLETE, loadSuccessHandler);
			removeEventListener(Event.ENTER_FRAME, loopHandler);
		}
	}
}